type math/big.nat
243 uses
math/big (current package)
decimal.go#L55: func (x *decimal) init(m nat, shift int) {
decimal.go#L72: m = nat(nil).rsh(m, s)
decimal.go#L78: m = nat(nil).lsh(m, uint(shift))
float.go#L71: mant nat
float.go#L582: func fnorm(m nat) int64 {
float.go#L695: func msb32(x nat) uint32 {
float.go#L713: func msb64(x nat) uint64 {
float.go#L1237: t := nat(nil).lsh(y.mant, uint(ey-ex))
float.go#L1248: t := nat(nil).lsh(x.mant, uint(ex-ey))
float.go#L1282: t := nat(nil).lsh(y.mant, uint(ey-ex))
float.go#L1293: t := nat(nil).lsh(x.mant, uint(ex-ey))
float.go#L1354: xadj = make(nat, len(x.mant)+d)
float.go#L1368: var r nat
ftoa.go#L186: mant := nat(nil).set(x.mant)
ftoa.go#L200: var tmp nat
ftoa.go#L332: m = nat(nil).lsh(m, uint(x.prec-w))
ftoa.go#L334: m = nat(nil).rsh(m, uint(w-x.prec))
ftoa.go#L383: m = nat(nil).lsh(m, n-w)
ftoa.go#L385: m = nat(nil).rsh(m, w-n)
int.go#L35: abs nat // absolute value of the integer
int.go#L121: z.abs = nat(abs).norm()
int.go#L283: _, z.abs = nat(nil).div(nil, z.abs, x.abs, y.abs)
int.go#L408: func low32(x nat) uint32 {
int.go#L416: func low64(x nat) uint64 {
int.go#L591: var mWords nat
int.go#L918: func (z nat) modInverse(g, n nat) nat {
int.go#L1135: t := nat(nil).sub(x.abs, natOne)
int.go#L1168: x1 := nat(nil).sub(x.abs, natOne)
int.go#L1169: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1187: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1198: x1 := nat(nil).sub(x.abs, natOne)
int.go#L1199: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1213: x1 := nat(nil).sub(x.abs, natOne)
int.go#L1220: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1231: x1 := nat(nil).sub(x.abs, natOne)
int.go#L1232: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1250: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1261: x1 := nat(nil).sub(x.abs, natOne)
int.go#L1262: y1 := nat(nil).sub(y.abs, natOne)
int.go#L1280: y1 := nat(nil).sub(y.abs, natOne)
nat.go#L35: type nat []Word
nat.go#L38: natOne = nat{1}
nat.go#L39: natTwo = nat{2}
nat.go#L40: natFive = nat{5}
nat.go#L41: natTen = nat{10}
nat.go#L44: func (z nat) String() string {
nat.go#L48: func (z nat) norm() nat {
nat.go#L56: func (z nat) make(n int) nat {
nat.go#L62: return make(nat, 1)
nat.go#L67: return make(nat, n, n+e)
nat.go#L70: func (z nat) setWord(x Word) nat {
nat.go#L79: func (z nat) setUint64(x uint64) nat {
nat.go#L91: func (z nat) set(x nat) nat {
nat.go#L97: func (z nat) add(x, y nat) nat {
nat.go#L123: func (z nat) sub(x, y nat) nat {
nat.go#L151: func (x nat) cmp(y nat) (r int) {
nat.go#L187: func (z nat) montgomery(x, y, m nat, k Word, n int) nat {
nat.go#L226: func alias(x, y nat) bool {
nat.go#L233: func addTo(z, x nat) {
nat.go#L246: func (z nat) mulRange(stk *stack, a, b uint64) nat {
nat.go#L256: return z.mul(stk, nat(nil).setUint64(a), nat(nil).setUint64(b))
nat.go#L265: return z.mul(stk, nat(nil).mulRange(stk, a, m), nat(nil).mulRange(stk, m+1, b))
nat.go#L318: func (s *stack) nat(n int) nat {
nat.go#L332: func (x nat) bitLen() int {
nat.go#L354: func (x nat) trailingZeroBits() uint {
nat.go#L367: func (x nat) isPow2() (uint, bool) {
nat.go#L378: func same(x, y nat) bool {
nat.go#L383: func (z nat) lsh(x nat, s uint) nat {
nat.go#L413: func (z nat) rsh(x nat, s uint) nat {
nat.go#L440: func (z nat) setBit(x nat, i uint, b uint) nat {
nat.go#L470: func (x nat) bit(i uint) uint {
nat.go#L481: func (x nat) sticky(i uint) uint {
nat.go#L501: func (z nat) and(x, y nat) nat {
nat.go#L518: func (z nat) trunc(x nat, n uint) nat {
nat.go#L531: func (z nat) andNot(x, y nat) nat {
nat.go#L548: func (z nat) or(x, y nat) nat {
nat.go#L567: func (z nat) xor(x, y nat) nat {
nat.go#L588: func (z nat) random(rand *rand.Rand, limit nat, n int) nat {
nat.go#L625: func (z nat) expNN(stk *stack, x, y, m nat, slow bool) nat {
nat.go#L693: var q nat
nat.go#L704: var zz, r nat
nat.go#L754: func (z nat) expNNMontgomeryEven(stk *stack, x, y, m nat) nat {
nat.go#L757: m1 := nat(nil).lsh(natOne, n)
nat.go#L758: m2 := nat(nil).rsh(m, n)
nat.go#L766: z1 := nat(nil).expNN(stk, x, y, m1, false)
nat.go#L767: z2 := nat(nil).expNN(stk, x, y, m2, false)
nat.go#L785: m2inv := nat(nil).modInverse(m2, m1)
nat.go#L797: func (z nat) expNNWindowed(stk *stack, x, y nat, logM uint) nat {
nat.go#L818: var powers [1 << n]nat
nat.go#L890: func (z nat) expNNMontgomery(stk *stack, x, y, m nat) nat {
nat.go#L896: _, x = nat(nil).div(stk, nil, x, m)
nat.go#L900: rr := make(nat, numWords)
nat.go#L917: RR := nat(nil).setWord(1)
nat.go#L918: zz := nat(nil).lsh(RR, uint(2*numWords*_W))
nat.go#L919: _, RR = nat(nil).div(stk, RR, zz, m)
nat.go#L926: one := make(nat, numWords)
nat.go#L931: var powers [1 << n]nat
nat.go#L974: _, zz = nat(nil).div(stk, nil, zz, m)
nat.go#L985: func (z nat) bytes(buf []byte) (i int) {
nat.go#L1022: func (z nat) setBytes(buf []byte) nat {
nat.go#L1044: func (z nat) sqrt(stk *stack, x nat) nat {
nat.go#L1062: var z1, z2 nat
nat.go#L1083: func (z nat) subMod2N(x, y nat, n uint) nat {
nat.go#L1089: x = nat(nil).trunc(x, n)
nat.go#L1097: y = nat(nil).trunc(y, n)
natconv.go#L109: func (z nat) scan(r io.ByteScanner, base int, fracOk bool) (res nat, b, count int, err error) {
natconv.go#L292: func (x nat) utoa(base int) []byte {
natconv.go#L297: func (x nat) itoa(neg bool, base int) []byte {
natconv.go#L368: q := nat(nil).set(x)
natconv.go#L405: func (q nat) convertWords(stk *stack, s []byte, b Word, ndigits int, bb Word, table []divisor) {
natconv.go#L409: var r nat
natconv.go#L480: bbb nat // divisor
natconv.go#L491: func (z nat) expWW(stk *stack, x, y Word) nat {
natconv.go#L492: return z.expNN(stk, nat(nil).setWord(x), nat(nil).setWord(y), nil, false)
natconv.go#L520: var larger nat
natconv.go#L524: table[0].bbb = nat(nil).expWW(stk, bb, Word(leafSize))
natconv.go#L527: table[i].bbb = nat(nil).sqr(stk, table[i-1].bbb)
natconv.go#L532: larger = nat(nil).set(table[i].bbb)
natdiv.go#L505: func (z nat) rem(stk *stack, u, v nat) (r nat) {
natdiv.go#L518: func (z nat) div(stk *stack, z2, u, v nat) (q, r nat) {
natdiv.go#L550: func (z nat) divW(x nat, y Word) (q nat, r Word) {
natdiv.go#L570: func (x nat) modW(d Word) (r Word) {
natdiv.go#L572: var q nat
natdiv.go#L597: func (z nat) divLarge(stk *stack, u, uIn, vIn nat) (q, r nat) {
natdiv.go#L646: func (q nat) divBasic(stk *stack, u, v nat) {
natdiv.go#L740: func (z nat) divRecursive(stk *stack, u, v nat) {
natdiv.go#L750: func (z nat) divRecursiveStep(stk *stack, u, v nat, depth int) {
natmul.go#L16: func (z nat) mul(stk *stack, x, y nat) nat {
natmul.go#L73: func (z nat) sqr(stk *stack, x nat) nat {
natmul.go#L113: func basicSqr(stk *stack, z, x nat) {
natmul.go#L136: func (z nat) mulAddWW(x nat, y, r Word) nat {
natmul.go#L151: func basicMul(z, x, y nat) {
natmul.go#L164: func karatsuba(stk *stack, z, x, y nat) {
natmul.go#L222: zz := make(nat, len(z))
natmul.go#L257: func karatsubaSqr(stk *stack, z, x nat) {
natmul.go#L309: zz := make(nat, len(z))
prime.go#L88: func (n nat) probablyPrimeMillerRabin(stk *stack, reps int, force2 bool) bool {
prime.go#L89: nm1 := nat(nil).sub(n, natOne)
prime.go#L92: q := nat(nil).rsh(nm1, k)
prime.go#L94: nm3 := nat(nil).sub(nm1, natTwo)
prime.go#L97: var x, y, quotient nat
prime.go#L152: func (n nat) probablyPrimeLucas(stk *stack) bool {
prime.go#L171: d := nat{1}
prime.go#L172: t1 := nat(nil) // temp
prime.go#L218: s := nat(nil).add(n, natOne)
prime.go#L221: nm2 := nat(nil).sub(n, natTwo) // n-2
prime.go#L251: natP := nat(nil).setWord(p)
prime.go#L252: vk := nat(nil).setWord(2)
prime.go#L253: vk1 := nat(nil).setWord(p)
prime.go#L254: t2 := nat(nil) // temp
rat.go#L77: func quotToFloat32(stk *stack, a, b nat) (f float32, exact bool) {
rat.go#L111: var a2, b2 nat
rat.go#L123: var q nat
rat.go#L175: func quotToFloat64(stk *stack, a, b nat) (f float64, exact bool) {
rat.go#L209: var a2, b2 nat
rat.go#L221: var q nat
rat.go#L314: babs = nat(nil).set(babs) // make a copy
rat.go#L428: return &Int{abs: nat{1}}
rat.go#L461: func mulDenom(stk *stack, z, x, y nat) nat {
rat.go#L475: func (z *Int) scaleDenom(stk *stack, x *Int, f nat) {
ratconv.go#L184: pow5 := z.b.abs.expNN(stk, natFive, nat(nil).setWord(Word(n)), nil, false) // use underlying array of z.b.abs
ratconv.go#L351: q, r := nat(nil).div(stk, nat(nil), x.a.abs, x.b.abs)
ratconv.go#L355: p = nat(nil).expNN(stk, natTen, nat(nil).setUint64(uint64(prec)), nil, false)
ratconv.go#L359: r, r2 := r.div(stk, nat(nil), r, x.b.abs)
ratconv.go#L366: q = nat(nil).add(q, natOne)
ratconv.go#L367: r = nat(nil).sub(r, p)
ratconv.go#L422: var q nat
ratconv.go#L432: var tab []nat // tab[i] == (5^fp)^(2^i) == 5^(fp·2^i)
ratconv.go#L433: f := nat{1220703125} // == 5^fp (must fit into a uint32 Word)
ratconv.go#L434: var t, r nat // temporaries
ratconv.go#L440: f = nat(nil).sqr(stk, f) // nat(nil) to ensure a new f for each table entry